// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g 2009-12-05 13:31:25

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;


public partial class diffLexer : Lexer {
    public const int PROP_SEP = 9;
    public const int RB = 20;
    public const int CRLF = 6;
    public const int CHAR = 22;
    public const int TAB = 16;
    public const int SEPARATOR = 7;
    public const int MINUS = 11;
    public const int REVISION = 18;
    public const int EOF = -1;
    public const int SPACE = 5;
    public const int ATS = 13;
    public const int INDEX = 4;
    public const int COMMA = 14;
    public const int NNL = 12;
    public const int PROP_CH = 8;
    public const int WORKING_COPY = 21;
    public const int LB = 17;
    public const int PLUS = 10;
    public const int DIGIT = 19;
    public const int CD = 15;

    // delegates
    // delegators

    public diffLexer() 
    {
		InitializeCyclicDFAs();
    }
    public diffLexer(ICharStream input)
		: this(input, null) {
    }
    public diffLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state) {
		InitializeCyclicDFAs(); 

    }
    
    override public string GrammarFileName
    {
    	get { return "C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g";} 
    }

    // $ANTLR start "NNL"
    public void mNNL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NNL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:47:6: ( '\\\\ No newline at end of file' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:47:8: '\\\\ No newline at end of file'
            {
            	Match("\\ No newline at end of file"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NNL"

    // $ANTLR start "CD"
    public void mCD() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CD;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:48:5: ( 'Cannot display: file marked as a binary type.' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:48:7: 'Cannot display: file marked as a binary type.'
            {
            	Match("Cannot display: file marked as a binary type."); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CD"

    // $ANTLR start "REVISION"
    public void mREVISION() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = REVISION;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:49:10: ( 'revision' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:49:12: 'revision'
            {
            	Match("revision"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "REVISION"

    // $ANTLR start "WORKING_COPY"
    public void mWORKING_COPY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WORKING_COPY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:50:14: ( 'working copy' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:50:16: 'working copy'
            {
            	Match("working copy"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WORKING_COPY"

    // $ANTLR start "PROP_CH"
    public void mPROP_CH() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = PROP_CH;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:51:10: ( 'Property changes on:' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:51:12: 'Property changes on:'
            {
            	Match("Property changes on:"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "PROP_CH"

    // $ANTLR start "SEPARATOR"
    public void mSEPARATOR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = SEPARATOR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:52:11: ( '===================================================================' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:52:13: '==================================================================='
            {
            	Match("==================================================================="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "SEPARATOR"

    // $ANTLR start "PROP_SEP"
    public void mPROP_SEP() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = PROP_SEP;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:53:10: ( '___________________________________________________________________' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:53:12: '___________________________________________________________________'
            {
            	Match("___________________________________________________________________"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "PROP_SEP"

    // $ANTLR start "SPACE"
    public void mSPACE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = SPACE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:54:8: ( ' ' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:54:10: ' '
            {
            	Match(' '); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "SPACE"

    // $ANTLR start "TAB"
    public void mTAB() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = TAB;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:55:6: ( '\\t' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:55:8: '\\t'
            {
            	Match('\t'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "TAB"

    // $ANTLR start "PLUS"
    public void mPLUS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = PLUS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:56:7: ( '+' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:56:9: '+'
            {
            	Match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MINUS"
    public void mMINUS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MINUS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:57:8: ( '-' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:57:10: '-'
            {
            	Match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "ATS"
    public void mATS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ATS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:58:6: ( '@@' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:58:8: '@@'
            {
            	Match("@@"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ATS"

    // $ANTLR start "COMMA"
    public void mCOMMA() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = COMMA;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:59:8: ( ',' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:59:10: ','
            {
            	Match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "LB"
    public void mLB() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LB;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:60:5: ( '(' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:60:7: '('
            {
            	Match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "LB"

    // $ANTLR start "RB"
    public void mRB() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = RB;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:61:5: ( ')' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:61:7: ')'
            {
            	Match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "RB"

    // $ANTLR start "DIGIT"
    public void mDIGIT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DIGIT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:62:8: ( '0' .. '9' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:62:10: '0' .. '9'
            {
            	MatchRange('0','9'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DIGIT"

    // $ANTLR start "INDEX"
    public void mINDEX() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = INDEX;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:63:8: ( 'Index:' )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:63:10: 'Index:'
            {
            	Match("Index:"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "INDEX"

    // $ANTLR start "CRLF"
    public void mCRLF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CRLF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:64:7: ( '\\r' | '\\n' | '\\r\\n' )
            int alt1 = 3;
            int LA1_0 = input.LA(1);

            if ( (LA1_0 == '\r') )
            {
                int LA1_1 = input.LA(2);

                if ( (LA1_1 == '\n') )
                {
                    alt1 = 3;
                }
                else 
                {
                    alt1 = 1;}
            }
            else if ( (LA1_0 == '\n') )
            {
                alt1 = 2;
            }
            else 
            {
                NoViableAltException nvae_d1s0 =
                    new NoViableAltException("", 1, 0, input);

                throw nvae_d1s0;
            }
            switch (alt1) 
            {
                case 1 :
                    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:64:9: '\\r'
                    {
                    	Match('\r'); 

                    }
                    break;
                case 2 :
                    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:64:16: '\\n'
                    {
                    	Match('\n'); 

                    }
                    break;
                case 3 :
                    // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:64:23: '\\r\\n'
                    {
                    	Match("\r\n"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CRLF"

    // $ANTLR start "CHAR"
    public void mCHAR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CHAR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:65:7: (~ ( '\\r' | '\\n' ) )
            // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:65:9: ~ ( '\\r' | '\\n' )
            {
            	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t') || (input.LA(1) >= '\u000B' && input.LA(1) <= '\f') || (input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CHAR"

    override public void mTokens() // throws RecognitionException 
    {
        // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:8: ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | INDEX | CRLF | CHAR )
        int alt2 = 19;
        alt2 = dfa2.Predict(input);
        switch (alt2) 
        {
            case 1 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:10: NNL
                {
                	mNNL(); 

                }
                break;
            case 2 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:14: CD
                {
                	mCD(); 

                }
                break;
            case 3 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:17: REVISION
                {
                	mREVISION(); 

                }
                break;
            case 4 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:26: WORKING_COPY
                {
                	mWORKING_COPY(); 

                }
                break;
            case 5 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:39: PROP_CH
                {
                	mPROP_CH(); 

                }
                break;
            case 6 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:47: SEPARATOR
                {
                	mSEPARATOR(); 

                }
                break;
            case 7 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:57: PROP_SEP
                {
                	mPROP_SEP(); 

                }
                break;
            case 8 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:66: SPACE
                {
                	mSPACE(); 

                }
                break;
            case 9 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:72: TAB
                {
                	mTAB(); 

                }
                break;
            case 10 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:76: PLUS
                {
                	mPLUS(); 

                }
                break;
            case 11 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:81: MINUS
                {
                	mMINUS(); 

                }
                break;
            case 12 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:87: ATS
                {
                	mATS(); 

                }
                break;
            case 13 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:91: COMMA
                {
                	mCOMMA(); 

                }
                break;
            case 14 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:97: LB
                {
                	mLB(); 

                }
                break;
            case 15 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:100: RB
                {
                	mRB(); 

                }
                break;
            case 16 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:103: DIGIT
                {
                	mDIGIT(); 

                }
                break;
            case 17 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:109: INDEX
                {
                	mINDEX(); 

                }
                break;
            case 18 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:115: CRLF
                {
                	mCRLF(); 

                }
                break;
            case 19 :
                // C:\\projects\\metrics-mon\\MetricsMonitor\\DiffParser\\diff.g:1:120: CHAR
                {
                	mCHAR(); 

                }
                break;

        }

    }


    protected DFA2 dfa2;
	private void InitializeCyclicDFAs()
	{
	    this.dfa2 = new DFA2(this);
	    this.dfa2.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA2_SpecialStateTransition);
	}

    const string DFA2_eotS =
        "\x01\uffff\x07\x13\x04\uffff\x01\x13\x04\uffff\x01\x13\x13\uffff";
    const string DFA2_eofS =
        "\x25\uffff";
    const string DFA2_minS =
        "\x01\x00\x01\x20\x01\x61\x01\x65\x01\x6f\x01\x72\x01\x3d\x01\x5f"+
        "\x04\uffff\x01\x40\x04\uffff\x01\x6e\x13\uffff";
    const string DFA2_maxS =
        "\x01\uffff\x01\x20\x01\x61\x01\x65\x01\x6f\x01\x72\x01\x3d\x01"+
        "\x5f\x04\uffff\x01\x40\x04\uffff\x01\x6e\x13\uffff";
    const string DFA2_acceptS =
        "\x08\uffff\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\uffff\x01\x0d\x01"+
        "\x0e\x01\x0f\x01\x10\x01\uffff\x01\x12\x01\x13\x01\x01\x01\x02\x01"+
        "\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01"+
        "\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x10\x01\x11";
    const string DFA2_specialS =
        "\x01\x00\x24\uffff}>";
    static readonly string[] DFA2_transitionS = {
            "\x09\x13\x01\x09\x01\x12\x02\x13\x01\x12\x12\x13\x01\x08\x07"+
            "\x13\x01\x0e\x01\x0f\x01\x13\x01\x0a\x01\x0d\x01\x0b\x02\x13"+
            "\x0a\x10\x03\x13\x01\x06\x02\x13\x01\x0c\x02\x13\x01\x02\x05"+
            "\x13\x01\x11\x06\x13\x01\x05\x0b\x13\x01\x01\x02\x13\x01\x07"+
            "\x12\x13\x01\x03\x04\x13\x01\x04\uff88\x13",
            "\x01\x14",
            "\x01\x15",
            "\x01\x16",
            "\x01\x17",
            "\x01\x18",
            "\x01\x19",
            "\x01\x1a",
            "",
            "",
            "",
            "",
            "\x01\x1f",
            "",
            "",
            "",
            "",
            "\x01\x24",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA2_eot = DFA.UnpackEncodedString(DFA2_eotS);
    static readonly short[] DFA2_eof = DFA.UnpackEncodedString(DFA2_eofS);
    static readonly char[] DFA2_min = DFA.UnpackEncodedStringToUnsignedChars(DFA2_minS);
    static readonly char[] DFA2_max = DFA.UnpackEncodedStringToUnsignedChars(DFA2_maxS);
    static readonly short[] DFA2_accept = DFA.UnpackEncodedString(DFA2_acceptS);
    static readonly short[] DFA2_special = DFA.UnpackEncodedString(DFA2_specialS);
    static readonly short[][] DFA2_transition = DFA.UnpackEncodedStringArray(DFA2_transitionS);

    protected class DFA2 : DFA
    {
        public DFA2(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;

        }

        override public string Description
        {
            get { return "1:1: Tokens : ( NNL | CD | REVISION | WORKING_COPY | PROP_CH | SEPARATOR | PROP_SEP | SPACE | TAB | PLUS | MINUS | ATS | COMMA | LB | RB | DIGIT | INDEX | CRLF | CHAR );"; }
        }

    }


    protected internal int DFA2_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            IIntStream input = _input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA2_0 = input.LA(1);

                   	s = -1;
                   	if ( (LA2_0 == '\\') ) { s = 1; }

                   	else if ( (LA2_0 == 'C') ) { s = 2; }

                   	else if ( (LA2_0 == 'r') ) { s = 3; }

                   	else if ( (LA2_0 == 'w') ) { s = 4; }

                   	else if ( (LA2_0 == 'P') ) { s = 5; }

                   	else if ( (LA2_0 == '=') ) { s = 6; }

                   	else if ( (LA2_0 == '_') ) { s = 7; }

                   	else if ( (LA2_0 == ' ') ) { s = 8; }

                   	else if ( (LA2_0 == '\t') ) { s = 9; }

                   	else if ( (LA2_0 == '+') ) { s = 10; }

                   	else if ( (LA2_0 == '-') ) { s = 11; }

                   	else if ( (LA2_0 == '@') ) { s = 12; }

                   	else if ( (LA2_0 == ',') ) { s = 13; }

                   	else if ( (LA2_0 == '(') ) { s = 14; }

                   	else if ( (LA2_0 == ')') ) { s = 15; }

                   	else if ( ((LA2_0 >= '0' && LA2_0 <= '9')) ) { s = 16; }

                   	else if ( (LA2_0 == 'I') ) { s = 17; }

                   	else if ( (LA2_0 == '\n' || LA2_0 == '\r') ) { s = 18; }

                   	else if ( ((LA2_0 >= '\u0000' && LA2_0 <= '\b') || (LA2_0 >= '\u000B' && LA2_0 <= '\f') || (LA2_0 >= '\u000E' && LA2_0 <= '\u001F') || (LA2_0 >= '!' && LA2_0 <= '\'') || LA2_0 == '*' || (LA2_0 >= '.' && LA2_0 <= '/') || (LA2_0 >= ':' && LA2_0 <= '<') || (LA2_0 >= '>' && LA2_0 <= '?') || (LA2_0 >= 'A' && LA2_0 <= 'B') || (LA2_0 >= 'D' && LA2_0 <= 'H') || (LA2_0 >= 'J' && LA2_0 <= 'O') || (LA2_0 >= 'Q' && LA2_0 <= '[') || (LA2_0 >= ']' && LA2_0 <= '^') || (LA2_0 >= '`' && LA2_0 <= 'q') || (LA2_0 >= 's' && LA2_0 <= 'v') || (LA2_0 >= 'x' && LA2_0 <= '\uFFFF')) ) { s = 19; }

                   	if ( s >= 0 ) return s;
                   	break;
        }
        NoViableAltException nvae2 =
            new NoViableAltException(dfa.Description, 2, _s, input);
        dfa.Error(nvae2);
        throw nvae2;
    }
 
    
}
